package com.mayisoftware.mayioa.business.plan.impl.serviceImpl;

import com.mayisoftware.mayioa.business.plan.api.constant.PlanCfgConstants;
import com.mayisoftware.mayioa.business.plan.api.domain.PlanCondition;
import com.mayisoftware.mayioa.business.plan.api.domain.PlanConfig;
import com.mayisoftware.mayioa.business.plan.api.service.IPlanConfigService;
import com.mayisoftware.mayioa.business.plan.impl.dao.PlanConditionMapper;
import com.mayisoftware.mayioa.business.plan.impl.dao.PlanConfigMapper;
import com.mayisoftware.mayioa.common.api.annotation.DataScope;
import com.mayisoftware.mayioa.common.impl.support.Convert;
import com.mayisoftware.mayioa.common.impl.utils.StringUtils;
import com.mayisoftware.mayioa.platform.impl.util.ShiroUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

/**
 * 计划配置 业务层处理
 * 
 *
 */
@Service
public class PlanConfigServiceImpl implements IPlanConfigService
{
    @Autowired
    private PlanConfigMapper planConfigMapper;

    @Autowired
    private PlanConditionMapper planConditionMapper;

    /**
     * 根据条件分页查询计划配置对象
     * 
     * @param planConfig 计划配置信息
     * 
     * @return 计划配置信息集合信息
     */
    @Override
    @DataScope(tableAlias = "pc")
    public List<PlanConfig> selectPlanConfigList(PlanConfig planConfig)
    {
        return planConfigMapper.selectPlanConfigList(planConfig);
    }

    /**
     * 通过计划名查询计划配置
     *
     * @param planCfgName 计划名
     * @return 计划配置对象信息
     */
    @Override
    public PlanConfig selectPlanConfigByName(String planCfgName) {
        return planConfigMapper.selectPlanConfigByName(planCfgName);
    }

    /**
     * 通过用户ID查询计划配置
     *
     * @param userId 用户ID
     * @return 计划配置对象信息
     */
    @Override
    public List<PlanConfig> selectPlanConfigByUserId( Long userId) {
        return planConfigMapper.selectPlanConfigByUserId(userId, ShiroUtils.getUserId());
    }

    /**
     * 通过计划配置ID查询计划配置
     * 
     * @param planConfigId 计划配置ID
     * @return 计划配置对象信息
     */
    @Override
    public PlanConfig selectPlanConfigById(Long planConfigId)
    {
        return planConfigMapper.selectPlanConfigById(planConfigId);
    }

    /**
     * 通过计划配置ID删除计划配置
     *
     * @param planConfigId 计划配置ID
     * @return 结果
     */
    @Override
    public int deletePlanConfigById(Long planConfigId) {

        return planConfigMapper.deletePlanConfigById(planConfigId);
    }

    /**
     * 批量删除计划配置信息
     * 
     * @param ids 需要删除的数据ID
     * @return 结果
     */
    @Override
    public int deletePlanConfigByIds(String ids) throws Exception
    {
        Long[] planConfigIds = Convert.toLongArray(ids);
        for (int i = 0; i < planConfigIds.length; i++) {
            Long planId = planConfigIds[i];
            // 删除计划与约束关联
            planConditionMapper.deletePlanConditionByPlanId(planId);
        }
        return planConfigMapper.deletePlanConfigByIds(planConfigIds);
    }

    /**
     * 新增计划配置信息
     * 
     * @param planConfig 计划配置信息
     * @return 结果
     */
    @Override
    public int insertPlanConfig(PlanConfig planConfig)
    {
        // 新增计划配置信息
        int rows = planConfigMapper.insertPlanConfig(planConfig);
        if(null != planConfig.getCondIds())
        {
            // 新增计划约束关联
            insertPlanCond(planConfig);
        }

        return rows;
    }

    /**
     * 新增计划约束关联信息
     * @param planConfig
     */
    public void insertPlanCond(PlanConfig planConfig)
    {
        List<PlanCondition> list = new ArrayList<PlanCondition>();
        PlanCondition pc = null;
        for (Long condId : planConfig.getCondIds())
        {
            pc = new PlanCondition();
            pc.setPlanCfgId(planConfig.getPlanCfgId().longValue());
            pc.setPlanCstrId(condId);
            list.add(pc);
        }
        if (list.size() > 0)
        {
            planConditionMapper.batchPlanCondition(list);
        }
    }

    /**
     * 修改保存计划配置信息
     * 
     * @param planConfig 计划配置信息
     * @return 结果
     */
    @Override
    public int updatePlanConfig(PlanConfig planConfig)
    {
        Integer planId = planConfig.getPlanCfgId();
        // 删除计划与约束关联
        planConditionMapper.deletePlanConditionByPlanId(planId.longValue());
        if(null != planConfig.getCondIds())
        {
            // 新增计划约束关联
            insertPlanCond(planConfig);
        }

        return planConfigMapper.updatePlanConfig(planConfig);
    }

    /**
     * 修改保存计划配置信息
     *
     * @param planConfig 计划配置信息
     * @return 结果
     */
    @Override
    public int publishPlanConfig(PlanConfig planConfig)
    {
        return planConfigMapper.updatePlanConfig(planConfig);
    }

    /**
     * 校验计划配置名称是否唯一
     * 
     * @param planConfig 计划配置对象
     * @return
     */
    @Override
    public String checkPlanCfgNameUnique(PlanConfig planConfig)
    {
        Integer planCfgId = StringUtils.isNull(planConfig.getPlanCfgId()) ? -1 : planConfig.getPlanCfgId();

        PlanConfig plan = planConfigMapper.checkPlanCfgNameUnique(planConfig.getPlanCfgName());
        if (StringUtils.isNotNull(plan) && plan.getPlanCfgId().longValue() != planCfgId.longValue())
        {
            return PlanCfgConstants.PLANCFG_NAME_NOT_UNIQUE;
        }
        return PlanCfgConstants.PLANCFG_NAME_UNIQUE;
    }

    /**
     * 校验计划配置是否已发布
     */
    @Override
    public int checkPlanCfgIsPublish(Long planCfgId)
    {
        return planConfigMapper.checkPlanCfgIsPublish(planCfgId);
    }

    /**
     * 查询计划配置
     * 
     * @return 结果
     */
    public List<PlanConfig> selectPlanConfigAll()
    {
        return planConfigMapper.selectPlanConfigAll();
    }

}
